/**
*功能：电子巡更 
*@created 20190909
*@author:luzhifei 
*/
var elePatrolObj={  
  
  originalInteractor:null, //原来的交互过滤器（正常模式下的过滤器，不允许设备移动)
  
  polyLine:null, //ht的折线
  points:[],	 //控制点基本信息
  segments:[],   //线段信息
  
  controlPointsPosMap:null,				   //控制点坐标数组数组
  controlPointTagPrefix:'ELE-PATROL-BALL-',//控制点的tag前缀
  controlPointDefaultHeight:50,	           //控制点y的默认高度
  controlPointYvalue:50, 	               //控制点y的高度，所有方法必须通过修改这个来控制控制点和动画模型的高度
  controlPointSize:125,	                   //控制点的半径(用于判断是否进入球体)
  tagNo:0,       //控制点的tagName序号，用于生成控制点的标签名称
  
  flagPic:'/assets/电子巡更/飘扬的小五星红旗.png',  //控制点旗帜的图像(最好是png）
  
  operationName:'none',       //操作名称，可以分为 gather,play,none分别表示采集，巡更,没有
  operationStatusName:'none', //操作状态名称，可以为on,pause,end,none 分别表示正在进行，暂停，完成,无状态
  waitTask:null,              //等待事件，用于当前模型非路线目标模型的情况下
  
  //播放参数,外部程序通过修改本参数来决定动画播放时候的表现（速度、路径显示/隐藏等等）
  playParam:{
	  firstPertonViewDistance:600, //第一人称视角的距离(非实际距离），越大则离动画模型越远
	  delay: 1500,  //延时
	  duration: 30000,//持久，越大则越慢
	  isShowRoad:false, //是否隐藏路径
	  linePattern:[16,16], //路径样式,如果是空的，则是实线，反之虚线。数值越大，分的段越多。后面一个数值表示线段之间的间距
	  viewType:'自由视角' ,//可以取值 '自由视角', '第一人称视角',
	  lineInfo:null,//线路信息,类型同接口 3.32  getPatrolLineInfo
	  lineRelatedVideoInfoArr:null,//线路相关的视频信息，是基于 getPatrolPointDevice的返回结构的map
	  linePointsMap:null,        //线路上控制点的的map结构信息，是为了方便从 lineInfo 中获取的
	  curControlPointNo:0,       //当前所在的控制点序号，如果是0，表示不在控制点内，否则就是在特定控制点内
	  transparentColor:'rgb(43,213,213,0.2)', //场景中墙透明的参数，前三位是rgb,最后一位是透明度，越小越透明，最大是1（不透明),0是完全透明
	  /**
	  *@功能：初始化参数
	  *@notice 暂时不用
	  */
	  init:function(){
		  this.delay= 1500;
		  this.duration= 30000;
		  this.isShowRoad= false; 
		  this.linePattern= [16,16];
		  this.viewType= '自由视角' ;
		  this.lineInfo= null;
		  this.lineRelatedVideoInfoArr=null;
		  if (this.linePointsMap!=null){
			  this.linePointsMap.clear();
		  }
          else{
			  this.linePointsMap=new Map();
		  }			  
	  },
	  setDelay:function(value){
		  this.delay=value;
		  if (elePatrolObj.operationName='play' && elePatrolObj.avObj!=null){
			  elePatrolObj.avObj.delay=value;
			  
		  }
	  },
	  //指定播放时候，模型的前进速度
	  setDuration:function(value){   
		  this.duration=value;
		  if (elePatrolObj.operationName='play' && elePatrolObj.avObj!=null){
			  elePatrolObj.avPlayControlParams.duration=value;
			  elePatrolObj.avObj.duration=value;
		  }
	  },
	  setFirstPertonViewDistance(value){
		  this.firstPertonViewDistance=value;
	  },
	  //行进路线是否隐藏
	  setIsShowRoad:function(value){
		  this.isShowRoad=value;
		  if (elePatrolObj.operationName='play' && elePatrolObj.avObj!=null){
			  elePatrolObj.polyLine.s('3d.visible',value);
			  dataModel.each(
			    function(data) {
					if (data.a('index')) {
						data.s('3d.visible', value);
					}
			    }
			  );
		  }
	  },
	  //设置折线的样式
	  setLinePattern:function(value){
		  this.linePattern=value;
		  if (elePatrolObj.polyLine!=null){
			  elePatrolObj.polyLine.s('shape.border.pattern',value!=null?value:null);
		  }
	  },
	  //指定视角，value只能取值  '自由视角', '第一人称视角'
	  setViewType:function(value){
		  this.viewType=value;
		  if (elePatrolObj.avObj!=undefined &&  elePatrolObj.avObj!=null){
			  if (value=='自由视角'){  //切换回正常的样子
			      if (elePatrolObj.avModel!=null){
					  let modelPos=elePatrolObj.avModel.getPosition3d();
					  modelPos[0]=modelPos[0]-300;
					  modelPos[1]=modelPos[1]+1000;
					  modelPos[2]=modelPos[2]+300;
					  // console.log('切换到自有视角');
					  g3d.setEye(modelPos);
				  }
			  }
			  else if (value=='第一人称视角'){
				  //切换到动画模型的后上方
				  console.log('第一视角');
			  }
		  }
	  },
	  //设定线路信息
	  setLineInfo:function(value){
		  this.lineInfo=value;
		  if (value!=null && value!=undefined){
			 if (this.linePointsMap==null){
				 this.linePointsMap=new Map();
			 }
             let controlCount=this.lineInfo.data.pointArray.length;
			 let pointArr=this.lineInfo.data.pointArray;
		     for(let i=0;i<controlCount;i++){ 
			    let mapkeyName=elePatrolObj.controlPointTagPrefix+(i+1);
				let mapValue={pointId:pointArr[i].pointId,
				              playCount:0,  //播放次数  
				              coordinate:{
								 x:pointArr[i].xcode*1,
								 y:pointArr[i].ycode*1,
								 z:pointArr[i].zcode*1
                              }								  
							 };
                this.linePointsMap.set(mapkeyName,mapValue);							 
			 }
		  }
		  
	  },
	  //设定线路信息相关的 视频信息
	  setLineRelatedVideoInfoArr:function(){
		  this.lineRelatedVideoInfoArr=value;
	  }
	  ,
	  //设置当前控制点序号
	  setCurControlPointNo:function(value){
		  this.curControlPointNo=value;
	  },
	  /**
	  *@created: 2019-09-25
	  *@author: 卢智飞
	  *@功能：设置当前模型的透明度(设置了之后，就无法恢复）
	  *@param value 透明颜色值 ,例如 'rgb(43,213,213,0.2)' 
	  *@param transType 透明的形式，可以取值 full,real。分别表示完全透明（看不到），和类似玻璃的透明效果
	  */
      setTransparent:function(value,transType){
         this.transparentColor=value;
		 if (transType!=undefined && transType=='real'){
			 g3d.dm().each(function(data) {
			   let tagName=data.getTag();
			   if (tagName!=elePatrolObj.avModelTagName){ 					
				   //方案2；真正的透明效果
				   data.s('all.color', elePatrolObj.playParam.transparentColor);
				   data.s('shape3d.color', elePatrolObj.playParam.transparentColor);
				   data.s('all.transparent', true);   //所有透明
				   data.s("shape3d.transparent", true);
				   data.s("shape3d.opacity", 0.2) ;			   
			   }
			 }); 
		 }
		 else{
			 g3d.dm().each(function(data) {
			   let tagName=data.getTag();
			   if (tagName!=elePatrolObj.avModelTagName || tagName==undefined || tagName==''){
				   //方案1:完全透明，但门等设备不透明
				   data.s('all.color', elePatrolObj.playParam.transparentColor);
				   data.s('shape3d.color', elePatrolObj.playParam.transparentColor);
				   data.s('all.transparent', true);   //所有透明
				   //data.s("all.reverse.flip",true);   //背拷贝 
				   data.s("front.transparent", true); //前面透明 
				   data.s("back.transparent",true);   //北面透明
				   data.s("left.transparent",true);   //左面透明
				   data.s("right.transparent",true);  //右面透明
				   data.s("top.transparent",true);    //顶部透明    
				   data.s("bottom.transparent", true);//底部透明
				   data.s("front.visible",false);     //前面不可见
				   data.s("back.visible",false);	  //后面不可见（没有设置不可见的，就是可见的)	 	   
			   }
			 }); 
		 }
      }
  }, 
  
  avObj:null,     //ht动画对象
  avModel:null,   //动画模型	
  avModelName:'hcjg001av',    //动画模型名称
  avModelTagName:'hcjg001av', //动画模型tag,便于查找过滤
  //动画控制参数,应用于 ht的av对象中
  avPlayControlParams:{
		delay: 1500,    //延时
	    duration: 30000,//持久
		easing: function(t) {
			return (t *= 2) < 1 ? 0.5 * t * t : 0.5 * (1 - (--t) * (t - 2));
		},
		action: function(v, t) {
			try{
				var length = g3d.getLineLength(elePatrolObj.polyLine),
					offset = g3d.getLineOffset(elePatrolObj.polyLine, length * v),
					point = offset.point,
					px = point.x,
					py = point.y,
					pz = point.z,
					tangent = offset.tangent,
					tx = tangent.x,
					ty = tangent.y,
					tz = tangent.z;
				elePatrolObj.avModel.p3(px, py, pz);
				elePatrolObj.avModel.lookAt([px + tx, py + ty, pz + tz], 'right');
				
				//检查是否已经来到了特定点内
				let pointKeyName=elePatrolObj.checkPoint(elePatrolObj.avModel.getPosition3d());
				if (pointKeyName!=null){
					// console.log(pointKeyName);
					let pointValue=elePatrolObj.playParam.linePointsMap.get(pointKeyName);
					let playCount=pointValue.playCount;
					if (playCount==undefined || playCount==null || playCount==0){
						// console.log('--i am playing movie of '+pointKeyName+'*********** 哈哈!');
						if (playCount==undefined || playCount==null){
							pointValue.playCount=0;
						}
						pointValue.playCount++;
						let curControlPointNo=pointKeyName.slice(elePatrolObj.controlPointTagPrefix.length)*1;
						elePatrolObj.playParam.setCurControlPointNo(curControlPointNo);
						elePatrolObj.playParam.linePointsMap.set(pointKeyName,pointValue);
						
						//记录当前到达的点
						vm.currentpoint=curControlPointNo;
					}
				}
				
				var camera = elePatrolObj.playParam.viewType;
				if (camera === '自由视角') {
					g3d.setCenter(px, py, pz);					
				} else if (camera === '第一人称视角') {
					g3d.setEye(px - tx * elePatrolObj.playParam.firstPertonViewDistance, 
						elePatrolObj.controlPointYvalue+50, pz - tz * elePatrolObj.playParam.firstPertonViewDistance);
					g3d.setCenter(px, py, pz);}

				elePatrolObj.avModel.a('angle', v * Math.PI * 120);
				if (this.duration * t % 1000 > 500) {
					elePatrolObj.avModel.a('light', false);
				} else {
					elePatrolObj.avModel.a('light', true);
				}
			}
			catch(exception){
				console.log(exception.message);
			}
		},
		finishFunc: function() {
			//不再周而复始
			//elePatrolObj.avObj = ht.Default.startAnim(params);
			elePatrolObj.avModel.a('light', false);
		}
  },
  
  
  /**
  *@功能：注销现有常规的事件
  *
  */
  unRegisterNormalEvent:function(){
     for (key in map) {
		if (key=='园区' || key=='building' || key=='floor') {
			g3d.umi(map[key].mi, g3d);
		}
	}
  },	  


   /**
   *@功能：键盘事件，按下p新增一个控制点.
   *
   */
   keyUpEvent:function(event) {
		if (event.keyCode == 80) {
			elePatrolObj.points.push({
				x: 0,
				y: 0,
				e: 20
			});
			elePatrolObj.polyLine.addPoint({
				x: 0,
				y: 0,
				e: 20
			});
			elePatrolObj.segments.push(2);
			elePatrolObj.polyLine.setSegments(elePatrolObj.segments);
			elePatrolObj.createControlPoint('xz');
		}
   },
   ////////////////////////////////////////////////////////////////////////////////////
   //播放
   //2019-09-20 考虑增加键盘c表示 清楚点设置重新开始 //TODO
   //
   
   /**
   *@功能:获取线路信息，并设置线路信息
   *@注意：
   *@param lineId 线路id，非空
   *@return 成功，则返回true,失败返回false.
   *线路信息和线路的视频信息，任意一个失败，都会返回false
   */
   getLineInfo:function(lineId){
	   let isOk=true;
	   $.ajax('/jg-api/patrol/getPatrolLineInfo', {
				data: {
					lineId: lineId,
				},
				dataType: 'json',
				type: 'post',
				async:false,
				success: (data) => {
					if(data.success){
						this.playParam.setLineInfo(data);
						//获取巡更详细
						vm.patroldetail=data;
					}
					else{
						isOk=false;
					}
				}
	  });
	  
	  if (!isOk){
		  return false;
	  }
	  
	  let pointCount=this.playParam.lineInfo.data.pointArray.length;
	  if (this.playParam.lineRelatedVideoInfoArr==null){
		  this.playParam.lineRelatedVideoInfoArr=new Map();
	  }
	  
	  // for(let  item of this.playParam.linePointsMap.entries()){
		 //  let pointId=item[1].pointId;
		 //  $.ajax('/jg-api/patrol/getPatrolPointDevice', {
			// 	data: {
			// 		pointId: pointId,
			// 	},
			// 	dataType: 'json',
			// 	type: 'post',
			// 	async:false,
			// 	success: (data) => {
			// 		if(data.success){
			// 			this.playParam.lineRelatedVideoInfoArr.set(item[0],data);
			// 		}
			// 		else{
			// 			isOk=false;
			// 		}
			// 	}
	  //     });
	  // }
 
   },   
   /**
   *@created :2019-09-24
   *@author: luzhifei 
   *@播放主体内容
   *@param  targetModelId 目标模型ID
   *@注意:  必须被 beginPlay 调用
   */
   playMain:function(targetModelId){
	   //如果目标模型不是已经加载的模型，则退出，继续等待0.1秒
	   if (modelMap.curModelId!=targetModelId || modelMap.modelLoadStatus!='finished'){ 
	     return ;
	   }
	   clearInterval(this.waitTask);
	   this.playParam.setTransparent('rgb(43,213,213,0.2)','real');
	   //注销现有的事件
	   this.unRegisterNormalEvent();	   
	   //设置状体
	   this.operationName='play';
	   this.operationStatusName='on';
	   //初始化变量--线路信息不清除
	   this.clearPlayParams();	
	   this.controlPointYvalue=modelMap.getFloorHeight(modelMap.curModelId,this.controlPointDefaultHeight);
       //保存老的交互过滤设置
	   this.originalInteractor=g3d.getInteractors();
	   //g3d.setInteractors(modelConfig.oldInteractors);
	   
       //加载av动画模型			   
	   //ht.Default.loadObj('/eledemo/jjr.obj', '/eledemo/jjr.mtl', {
	   ht.Default.loadObj('/scenes/巡检机器人.obj', '/scenes/巡检机器人.mtl', {
			center: true,
			r3: [0, -Math.PI / 2, 0], 
			s3: [0.1, 0.1, 0.1],      // 模型较大，需要适当缩小
			finishFunc: function(mm, array, rawS3) {
				if (mm) {
					//添加一个指示灯
					array.push({
						shape3d: ht.Default.createSmoothSphereModel(),
						t3: [-5, 2, 0], //平移，避免太近
						s3: [2, 2, 2],
						color: {
							func: function(data) {
								return data.a('light') ? 'red' : 'black';
							}
						}
					});
					ht.Default.setShape3dModel(elePatrolObj.avModelName, array);
					elePatrolObj.createPatrolModel(rawS3);
				}
			}
	   });
	   
	   //创建路径,路径的起点，应该是参数中的第一个点
	   let startX=this.playParam.lineInfo.data.pointArray[0].xcode*1;
	   let startZ=this.playParam.lineInfo.data.pointArray[0].zcode*1;

       
	   g3d.setDashDisabled(false);
	   this.createPath(startX,startZ);
	   //创建第一个点
	   this.createControlPoint('xz');
	   //创建其它点
	   this.createPlayControlPoints('xz');
	   //设置路线--可见，并是实线
       this.playParam.setIsShowRoad(true);
	   this.playParam.setLinePattern(null);
	   //启动ht 动画
	   this.avObj = ht.Default.startAnim(this.avPlayControlParams);
   },
   /**
   *@功能：开始播放
   *@注意：播放之前，有关的参数已经设定好了.这些参数包括playParam中的线路信息
   *@return  成功返回 ok,失败返回其它信息
   */
   beginPlay:function(){

	   let modelId=this.playParam.lineInfo.data.modelId;
	   let modelName=modelMap.getModelNameByModelId(modelId);
	   if (modelName==undefined || modelName==null){
		   return '模型ID【'+modelId+'】没有对应的模型文件,请确保模型编码和模型文件名称的正确映射!';
	   }
	   
	   if (modelMap.curModelId==modelId){ //如果是当前模型则什么也不做
		   this.playMain(modelId);
	   }
	   else{
		   //否则启动一个事件，等待模型加载完毕再执行
		   loadModel(modelName,map);
		   this.waitTask=setInterval(function(){
			   elePatrolObj.playMain(elePatrolObj.playParam.lineInfo.data.modelId);
           },100);
		   
	   }
	   return 'ok';	
			
   },
   /**
   *@功能：创建巡更模型(用于播放)
   *@注意：
   */
   createPatrolModel:function(rawS3){
		this.avModel = new ht.Node();
		//this.avModel.s3(20, 20, 20);
		this.avModel.s3(rawS3);		
		this.avModel.s({
			'shape3d': elePatrolObj.avModelName,
			'shape3d.scaleable': true,
			'wf.visible': false,
			'wf.color': 'white',
			'wf.short': true
		});
		this.avModel.a({
			'angle': 0,
			'light': false
		});
		this.avModel.setTag(this.avModelTagName);
		dataModel.add(this.avModel);
   },
   /**
   *@功能：清除播放有关变量
   *
   */
   clearPlayParams:function(){
	   this.polyLine=null;
	   this.points.length=0;
	   this.segments.length=0;
	   this.tagNo=0;
	   if (this.controlPointsPosMap==null){
		   this.controlPointsPosMap=new Map();
	   }
	   else{
	     this.controlPointsPosMap.clear();
	   }
	   this.avModel=null;
	   this.avObj=null;
	   this.playParam.setCurControlPointNo(0);
   },	   
   
   /**
   *@功能:检查是否落在了特定点内，如果是则计数加1
   *@param  curPos ,动画模型在当前模型中的位置
   *@return 如果落在特定控制点，则返回当前控制点的key(实际是node的tagName),否则返回null
   */
   checkPoint:function(curPos){
		let resKey=null;
		this.playParam.linePointsMap.forEach(function(value,key){
　　　　　　　　 //console.log(value,key);
			 if (curPos[0]>value.coordinate.x-elePatrolObj.controlPointSize &&  curPos[0]<value.coordinate.x+elePatrolObj.controlPointSize
				&& curPos[1]>value.coordinate.y-elePatrolObj.controlPointSize &&  curPos[1]<value.coordinate.y+elePatrolObj.controlPointSize
				&& curPos[2]>value.coordinate.z-elePatrolObj.controlPointSize &&  curPos[2]<value.coordinate.z+elePatrolObj.controlPointSize){
					resKey= key;
			 }
　　　　});
   
		return resKey;
   },   
   /**
   *@功能：暂停播放,状态名称设置为 pause
   */
   pausePlay:function(){
	   this.avObj.pause();
	   this.operationStatusName='pause';
   },
   
   /**
   *@功能：恢复播放，状态名称设置为on 
   */
   resumePlay:function(){
	   this.avObj.resume();
	   this.operationStatusName='on';
   },
   
   /**
   *@created 2019-09-22
   *@author luzhifei 
   *@功能：重新播放
   *@注意事项： 只适用于 beginPlay执行一次，且已经停止的情况
   */
   rePlay:function(){
	   //重置 线路控制点的计数信息--设置为0
	   for(let  item of this.playParam.linePointsMap.entries()){
		  item[1].playCount=0;
	   }
	   this.avObj = ht.Default.startAnim(this.avPlayControlParams);
   },
   
   /**
   *@功能：完成播放,但是并没有退出.
   */
   finishPlay:function(){
	  this.avObj.stop(); 
   },
   
   /**
   *@功能：退出播放,回复当前模型状态
   */
   exitPlay:function(){
	   if (this.avObj.isRunning()){
		   this.avObj.stop();
	   }
	   this.operationName='none';
	   this.operationStatusName='none';
	   this.controlPointsPosMap.clear(); //清除数据
	   g3d.dm().clear();
	   loadModel(modelMap.curModelFileName,map);
	   g3d.setInteractors(this.originalInteractor);
	   //清除变量设置
	   this.clearPlayParams();
	   //注销特有的事件
	   g3d.umi(this.playEvent);
   },
   
   ////////////////////////////////////////////////////////////////////////////////////
   //采集
   /**
   *@功能：开始采集
   *@注意: 只能在特定的模型上采集，目前只支持floor
   *@param yValue 控制点的y坐标值，相当于高度
   *@return 如果正确开始采集，则返回ok,否则返回 其它的信息(错误)!
   */
   beginGather:function(yValue){
	   if (modelConfig.modelLevelName!='floor'){
		   return '必须在楼层模型才可以采集!';
	   }
	   this.operationName='gather';
	   this.operationStatusName='on';
	   //初始化变量
	   this.polyLine=null;
	   this.points.length=0;
	   this.segments.length=0;
	   this.tagNo=0;
	   if (this.controlPointsPosMap==null){
		   this.controlPointsPosMap=new Map();
	   }
	   else{
	     this.controlPointsPosMap.clear();
	   }
	   if (yValue!=undefined && yValue!=null){
	     this.controlPointYvalue=yValue;
	   }
	   else{
		 this.controlPointYvalue=modelMap.getFloorHeight(modelMap.curModelId,this.controlPointDefaultHeight);
	   }
	   //创建一个初始点
	   g3d.setDashDisabled(false);		   
	   this.createPath();
	   this.createControlPoint('xz');
	   //注销现有的事件
	   this.unRegisterNormalEvent();
	   //让设备可以移动
	   this.originalInteractor=g3d.getInteractors();
	   g3d.setInteractors(modelConfig.oldInteractors);
	   //注册键盘事件，使用p键来增加新的控制点
	   window.addEventListener('keyup',this.keyUpEvent,false);
	   return 'ok';
   },
   /**
   *@功能：取消采集,并重新加载有关的模型(恢复模型状态)
   *@注意:  
   */
   cancelGather:function(){
	   if (modelConfig.modelLevelName!='floor'){
		   return;
	   }
	   //回复标记
	   this.operationName='none';
	   this.operationStatusName='none';
	   
	   //注销键盘事件 
	   window.removeEventListener('keyup',this.keyUpEvent,false);
	   //需要重新加载模型
	   loadModel(modelMap.curModelFileName,map);
	   g3d.setInteractors(this.originalInteractor);
   },
   /**
   *@功能：完成采集
   *@return 如果是合法的则返回顺序的点位信息,否则返回null
   * 合法的要求是至少有两个点
   *@param isForce 是否强制退出
   */
   exitGather:function(isForce){
	    let resultValue=null;
		g3d.dm().each(function(item){
			  let tagName=item.getTag();				  
			  if (tagName!=undefined && tagName.indexOf(elePatrolObj.controlPointTagPrefix)!=-1){
				  elePatrolObj.controlPointsPosMap.set(tagName,item.getPosition3d());
			  }			
		});

		let pointArr=new Array();
		for(var i=1,len=this.controlPointsPosMap.size;i<=len;i++){
			pointArr.push(this.controlPointsPosMap.get(this.controlPointTagPrefix+i));
		}
		
		if (isForce==true || pointArr.length>1){
			this.operationName='none';
			this.operationStatusName='none';
			this.controlPointsPosMap.clear(); //清除数据
			g3d.dm().clear();
			loadModel(modelMap.curModelFileName,map);
			g3d.setInteractors(this.originalInteractor);
			//注销键盘事件 
	        window.removeEventListener('keyup',this.keyUpEvent,false);
		}
		
		if (pointArr.length<=1){
			pointArr=null;
		}
		// console.log(pointArr);
		return pointArr;
   },
  
	/**
	*功能：创建路径
	*@param px x坐标值
	*@param pz z坐标值
	*/
   createPath:function(px,pz) {
		this.polyLine = new ht.Polyline();
		this.polyLine.setThickness(2);
		this.polyLine.s({
			'shape.border.pattern':[16, 16],
			'shape.border.color': 'red',
			'shape.border.gradient.color': 'yellow',  //渐变颜色
			'shape3d.resolution': 300,
			//'shape.border.width':20, //线框宽度
			//'shape.dash.width':16,   //线宽度
			'3d.selectable': false
		});
        this.polyLine.setTag('avMovingLine');		
		dataModel.add(this.polyLine);

        let pointX=px;
        if (pointX==null || pointX==undefined){
			pointX=138; //中心点附近
		}			
		
		let pointZ=pz;
        if (pointZ==null || pointZ==undefined){
			pointZ=50; //中心点附近
		}			
		
		// 定义起始点
		this.points = [{
			x: pointX,
			y: pointZ,
			e: this.controlPointYvalue
		}];
		this.segments = [1];

		this.polyLine.setPoints(this.points);
		this.polyLine.setSegments(this.segments);

		g3d.sm().setSelectionMode('single');
		g3d.mi(this.playEvent);
		/* g3d.mi(function(e) {
			if (e.kind === 'betweenMove' || e.kind === 'endMove') {
				var data = g3d.sm().ld();
				if (data && data.a('index') != null) {
					var p3 = data.p3();
					elePatrolObj.polyLine.setPoint(data.a('index'), {
						x: p3[0],
						e: p3[1],
						y: p3[2]
					});
				}
			}
		}); */
		
		
	},
	/**
	*@author luzhifei
	*@created 20190927
	*@功能: 当模型旋转的时候，调整折线信息
	*/
	playEvent:function(e){
		if (e.kind === 'betweenMove' || e.kind === 'endMove') {
			let selItem = g3d.sm().ld();
			if (selItem && selItem.a('index') != null) {
				let  p3 = selItem.p3();
				elePatrolObj.polyLine.setPoint(selItem.a('index'), {
					x: p3[0],
					e: p3[1],
					y: p3[2]
				});
			}
		}
	},
	/**
	*@功能: 创建控制点(适用于采集,和播放时候的第一个点)
	*@注意：由于旗子的缘故，会导致旗杆在地板下面
	*/		
	createControlPoint:function(moveMode) {
		var index = this.points.length - 1,
			point = this.points[index],
			node = new ht.Node();
		node.s({
				'shape3d': 'billboard',
				'shape3d.image':this.flagPic,
				'3d.movable': true,
				'2d.movable': false,
				'3d.selectable': true,
				'shape3d.image.cache': true, // 是否缓存
				'shape3d.autorotate': true, // 始终面向相机
				"shape3d.transparent": true,
				'shape3d.alwaysOnTop': false, ////---- 是否需要一直在上方
				'shape3d.vector.dynamic': false,
				'shape3d.fixSizeOnScreen': false,
		});
		
		node.s3(25, 25, 25);
		node.a({
			index: index
		});
		
		this.tagNo++;
		let tagName=this.controlPointTagPrefix+this.tagNo;
		node.setTag(tagName);
		node.setScale3d([10,10,10]); 
		node.p3(point.x,this.controlPointYvalue , point.y);
		dataModel.add(node);
		if (this.tagNo==1){  //第一个拉近视角，展示友好度
			g3d.flyTo(node, 
			  {
				animation: true,
				direction:[2,5,0],
				ratio: 0.04
			  }
		   );
		}
	},

    /**
	*@功能: 创建播放时候的控制点
	*@注意：
	*/		
	createPlayControlPoints:function(moveMode) {
		
		let controlCount=this.playParam.lineInfo.data.pointArray.length;
		for(let i=1;i<controlCount;i++){
			//创建新的点数据
			let startX=this.playParam.lineInfo.data.pointArray[i].xcode*1;
			let startZ=this.playParam.lineInfo.data.pointArray[i].zcode*1;
			
			this.points.push({
				x: startX,
				y: startZ,
				e: this.controlPointYvalue
			});
			this.polyLine.addPoint({
				x: startX,
				y: startZ,
				e: this.controlPointYvalue
			});
			this.segments.push(2);
			this.polyLine.setSegments(this.segments);
			
			//创建新的点
			//let pointIndex = this.points.length - 1;
			let point = this.points[i];
			
			let node = new ht.Node();
			node.s({
					'shape3d': 'billboard',					
					'shape3d.image':this.flagPic,
					'3d.movable': true,
					'2d.movable': false,
					'3d.selectable': true,
					'shape3d.image.cache': true, // 是否缓存
					'shape3d.autorotate': true, // 始终面向相机
					"shape3d.transparent": true,
					'shape3d.alwaysOnTop': false, ////---- 是否需要一直在上方
					'shape3d.vector.dynamic': false,
					'shape3d.fixSizeOnScreen': false,
			});
			
			node.s3(25, 25, 25);
	 
			node.a({
				index: i
			});
			
			this.tagNo++;
			let tagName=this.controlPointTagPrefix+this.tagNo;
			node.setTag(tagName);
			node.setScale3d([10,10,10]); 
			node.p3(point.x,this.controlPointYvalue , point.y);
			dataModel.add(node);
        }
	}
	,
	/*
   *功能，进行睡眠
   *@Param  startTime  开始时间 （ms)
   *@Param  sleepTimeMs  休眠时间(ms)
   */
   sleep:function(startTime,sleepTimeMs){
	  let nt=new Date();
	  while(nt - startTime <= sleepTimeMs){
		   nt=new Date();
	  };
   }
};